package com.efast.dmom.mgmt.service.les.impl;

import com.efast.cafe.framework.spring.SpringContextUtils;
import com.efast.dmom.mgmt.bean.les.ImmediateReplenishmentByLibraryBean;
import com.efast.dmom.mgmt.bean.les.ImmediateReplenishmentByRequestBean;
import com.efast.dmom.mgmt.entity.les.*;
import com.efast.dmom.mgmt.entity.master.TmBasDpath;
import com.efast.dmom.mgmt.service.les.ImmediateReplenishmentJobService;
import com.efast.dmom.mgmt.service.les.TtWhmStockOutboundService;
import com.efast.dmom.mgmt.service.les.TwBasPackSkuQtyService;
import com.efast.dmom.mgmt.service.les.TwInvPacktranDetailService;
import com.efast.dmom.mgmt.service.les.TwInvPacktranHeaderService;
import com.efast.dmom.mgmt.service.les.TwInvPalMriService;
import com.efast.dmom.mgmt.utils.Assist;

import com.efast.dmom.mgmt.utils.MesConstant;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 即时补货 : Immediate replenishment , 后台job，根据零件仓储关系里的配置自动执行；
 * 
 * @author ChenLiPeng
 */
@Service
public class ImmediateReplenishmentJobServiceImpl implements ImmediateReplenishmentJobService {

	/**
	 *
	 * 补货任务需求 TW_INV_PAL_MRI
	 */
	@Autowired
	private TwInvPalMriService twInvPalMriService;
	
	/**
	 *
	 * 补货余量需求TW_BAS_PACK_SKU_QTY
	 */
	@Autowired
	private TwBasPackSkuQtyService twBasPackSkuQtyService;
	/**
	 * 出库记录 TT_WHM_STOCK_OUTBOUND
	 *
	 */
	@Autowired
	private TtWhmStockOutboundService ttWhmStockOutboundService;
	/**
	 *
	 * 补货任务头表 TW_INV_PACKTRAN_HEADER
	 */
	@Autowired
	private TwInvPacktranHeaderService twInvPacktranHeaderService;
	/**
	 *
	 * 补货任务明细TW_INV_PACKTRAN_DETAIL
	 */
	@Autowired
	private TwInvPacktranDetailService twInvPacktranDetailService;

	@Override
	public void execute() {

		// 【1】：查询出所有的补货路径
		List<TmBasDpath> listTmBasDpath = twInvPalMriService.queryAllPath();

		// 【2】：遍历所有的补货路径，查询每条补货路径下面的工位
		for (TmBasDpath tmBasDpath : listTmBasDpath) {

			// 【3】：按出库(按照wms实际出库记录算消耗)：按照补货路径归类 ，查询所有补货路径下面的库位零件消耗。
			// 根据补货路径，查询出改路径下面所有的工位
			List<ImmediateReplenishmentByLibraryBean> partConsumptionBeanList = twInvPalMriService.queryTimelyReplenishmentByLibrary(
					tmBasDpath.getTmBasDpathId());

			for (int i = 0; i < partConsumptionBeanList.size(); i++) {
				ImmediateReplenishmentByLibraryBean iRL = partConsumptionBeanList.get(i);
				// 【4】：查询出未组织的零件库位消耗
				List<TwBasPackSkuQty> listTwBasPackSkuQty = twBasPackSkuQtyService.selectTwBasPackSkuQty(
						new Assist(Assist.andEq("tw_bas_pack_sku_qty.part_no_version", iRL.getPartNoVersion()),
								Assist.andEq("tw_bas_pack_sku_qty.loc_no", iRL.getLocNo()),
								Assist.andEq("tw_bas_pack_sku_qty.mri_status", "0")));
				TwBasPackSkuQty twBasPackSkuQty;
				//Integer count = iRL.getOutboundQty();
				Integer count=0;
				if (listTwBasPackSkuQty.size() > 0) {
					twBasPackSkuQty = listTwBasPackSkuQty.get(0);
					//count += twBasPackSkuQty.getStorageQty();
					count =twBasPackSkuQty.getStorageQty();
				}

				// 【5】：判断库位零件： 消耗量/包装容量是否大于1箱。如果>=1箱时，产生补货需求。
				if (count / iRL.getInboundPackQty() >= 1) {

					// 【6】：生成 补货任务头表 TW_INV_PACKTRAN_HEADER
					TwInvPacktranHeader twInvPacktranHeader = new TwInvPacktranHeader();
					// 任务状态（新任务0，任务确认1，任务完成2，任务部分完成3，关闭4）
					twInvPacktranHeader.setPacktranStatus("0");
					// 补货任务单打印状态（0打印1已打印）
					twInvPacktranHeader.setPrintStatus("0");
					// 补货类型（1即时补货 2按库存消耗补货 3按累计消耗补货）
					twInvPacktranHeader.setPacktranType("1");
					// 补货路径
					twInvPacktranHeader.setRebRoad(tmBasDpath.getDpathNo());
					// 目的地
					twInvPacktranHeader.setDeliveryRec(tmBasDpath.getDeliveryRec());
					twInvPacktranHeader.setMarkStatus(1);
					twInvPacktranHeader.setCreateTime(new Date());
					twInvPacktranHeader.setTaskCreatetime(new Date());
					Map<String, Object> map = twInvPacktranHeaderService.insertNonEmptyTwInvPacktranHeader(
							twInvPacktranHeader);

					// 【7】：补货任务明细TW_INV_PACKTRAN_DETAIL
					TwInvPacktranDetail twInvPacktranDetail = new TwInvPacktranDetail();
					BeanUtils.copyProperties(iRL, twInvPacktranDetail);
					twInvPacktranDetail.setTwInvPacktranHeaderId((int) map.get("twInvPacktranHeaderId"));
					// 零件号
					twInvPacktranDetail.setPartNoVersion(iRL.getPartNoVersion());
					// 供应商编号
					twInvPacktranDetail.setSupplNo(iRL.getSupplNo());
					// 零件中文名称
					twInvPacktranDetail.setPartNamec(iRL.getPartNamec());
					// 零件基本单位
					twInvPacktranDetail.setBaseUnit(iRL.getBaseUnit());
					// 物料目标仓库
					twInvPacktranDetail.setAfterPartWarehouse(iRL.getAfterPartWarehouse());
					// 物料目标库区
					twInvPacktranDetail.setAfterPartDloc(iRL.getAfterPartDloc());
					// 物料目标库位
					twInvPacktranDetail.setAfterPartLoc(iRL.getAfterPartDloc());
					// 源仓库
					twInvPacktranDetail.setPFromWarehouseId(iRL.getpFromWarehouseId());
					// 源库区
					twInvPacktranDetail.setPFromDlocId(iRL.getpFromDlocId());
					// 源库位
					twInvPacktranDetail.setPFromLocId(iRL.getpFromLocId());
					// 要求补货数量
					twInvPacktranDetail.setPrePacktranQty(count);
					// 要求补货包装数量
					twInvPacktranDetail.setPacktranPacknum(count / iRL.getInboundPackQty());
					// 要求补货包装容量
					twInvPacktranDetail.setPacktranPackqty(iRL.getInboundPackQty());
					// 补货类型 1:即时补货 , 2:按库存消耗补货 3:按累计消耗补货
					twInvPacktranDetail.setPacktranType("1");
					// 创建类型（自动/人工）
					twInvPacktranDetail.setTaskCreateType("0");
					// 补货任务行状态
					twInvPacktranDetail.setTaskStatue("0");
					// 指令创建时间
					twInvPacktranDetail.setTaskCreateTime(new Date());
					// 目的地
					twInvPacktranDetail.setDeliveryRec(tmBasDpath.getDeliveryRec());
					// 补货任务单号
					twInvPacktranDetail.setPacktranSheetNo((String) map.get("packtranSheetNo"));
					// 行号
					twInvPacktranDetail.setLineNo(i + 1);
					// 是否需要分配库存(0:无来源库位需要分配|1：有来源库位，不需要分配)
					// 此处的逻辑，决定补货管理页面，是否需要分配库位的处理逻辑
					// 不一定是及时补货就一定有补货来源库位的，这个是在零件仓储关系里面配置的，可以配置也可以不用配置
					if (iRL.getpFromLocId() != null && iRL.getAfterPartDloc() != null) {
						twInvPacktranDetail.setAcallFlag("1");
					}
					if (iRL.getpFromLocId() == null && iRL.getAfterPartDloc() != null) {
						twInvPacktranDetail.setAcallFlag("0");
					}
					twInvPacktranDetail.setMarkStatus(1);
					twInvPacktranDetail.setCreateTime(new Date());
					twInvPacktranDetailService.insertTwInvPacktranDetail(twInvPacktranDetail);

					// 【8】： 往补货需求表(TW_INV_PAL_MRI)中，插入数据
					TwInvPalMri twInvPalMri = new TwInvPalMri();
					// 实际补货数量
					twInvPalMri.setActRepQty(0);
					// 补货任务单id
					twInvPalMri.setTwInvPacktranHeaderId((int) map.get("twInvPacktranHeaderId"));
					// 补货任务单明细id
					twInvPalMri.setTwInvPacktranDetailId(twInvPacktranDetail.getTwInvPacktranDetailId());
					// 补货任务单号
					twInvPalMri.setPacktranSheetNo((String) map.get("packtranSheetNo"));
					// 补货任务类型(1:即时补货;2:按库存消耗补货3按累计消耗补货)
					twInvPalMri.setPacktranType("1");
					twInvPalMri.setPartNoVersion(iRL.getPartNoVersion());
					// 供应商编号
					twInvPalMri.setSupplNo(iRL.getSupplNo());
					// 零件中文名称
					twInvPalMri.setPartNamec(iRL.getPartNamec());
					// 零件基本单位
					twInvPalMri.setBaseUnit(iRL.getBaseUnit());
					// 补货任务目标仓库
					twInvPalMri.setAfterPartWarehouse(iRL.getAfterPartWarehouse());
					// 补货任务目标库区
					twInvPalMri.setAfterPartDloc(iRL.getAfterPartDloc());
					// 补货任务目标库位
					twInvPalMri.setAfterPartLoc(iRL.getAfterPartLoc());
					// 补货任务来源仓库
					twInvPalMri.setpFromWarehouseId(iRL.getpFromWarehouseId());
					// 补货任务来源库区
					twInvPalMri.setpFromDlocId(iRL.getpFromDlocId());
					// 补货任务来源库位
					twInvPalMri.setpFromLocId(iRL.getpFromLocId());
					// 要求补货数量
					twInvPalMri.setPrePacktranQty(count);
					// 要求补货包装代码
					twInvPalMri.setPacktranPackno(iRL.getPacktranPackno());
					// 要求补货包装数量(箱数)
					twInvPalMri.setPacktranPacknum(count / iRL.getInboundPackQty());
					// 要求补货包装容量
					twInvPalMri.setPacktranPackqty(iRL.getInboundPackQty());
					// 补货任务创建时间
					twInvPalMri.setPacktranCreatetime(new Date());
					// 补货任务需求状态(0:未组织;1已组织2:补货任务完成3:关闭)
					twInvPalMri.setMriStatue("1");
					// 货主 默认''qoros'' 【不确定】
					twInvPalMri.setCustomerid(MesConstant.DELIVERY_UNIT_NO);
					// 收货地
					twInvPalMri.setDeliveryRec(iRL.getDeliveryRec());
					// 补货路径
					twInvPalMri.setDpathNo(iRL.getDpathNo());
					// 是否翻dolley
					twInvPalMri.setDolleyFlag(iRL.getDolleyFlag());
					// 是否激活
					twInvPalMri.setMarkStatus(1);
					twInvPalMriService.insertNonEmptyTwInvPalMri(twInvPalMri);

					// 【9】 将已经使用的余量(tw_bas_pack_sku_qty)更新成 “已组织”的状态
					if (listTwBasPackSkuQty.size() > 0) {
						TwBasPackSkuQty twBasPackSkuQty3 = new TwBasPackSkuQty();
						twBasPackSkuQty3.setMriStatus("1");
						twBasPackSkuQtyService.updateNonEmptyTwBasPackSkuQty(twBasPackSkuQty3,
								new Assist(Assist.andEq("tw_bas_pack_sku_qty.part_no_version", iRL.getPartNoVersion()),
										Assist.andEq("tw_bas_pack_sku_qty.loc_no", iRL.getLocNo()),
										Assist.andEq("tw_bas_pack_sku_qty.mri_status", "0")));
					}

					// 【10】 余数表(TW_BAS_PACK_SKU_QTY)重置：对应的余数置为完成状态，另起一行记录，插入余数。
					// 余数
					Integer remainder = count  % iRL.getInboundPackQty();
					WindowReplenishmentByCumulativeConsumptionJobServiceImpl.generateRemainder(twBasPackSkuQtyService,
							iRL, remainder);

					// 【11】完成后需要将出库记录(TT_WHM_STOCK_OUTBOUND)补货组织状态置为完成
					TtWhmStockOutbound ttwhmstockoutbound = new TtWhmStockOutbound();
					ttwhmstockoutbound.setTtWhmStockOutboundId(iRL.getTt_whm_stock_outbound_id());
					// 补货需求状态(0:未组织,1:已组织)
					ttwhmstockoutbound.setMriStatus("1");
					ttWhmStockOutboundService.updateNonEmptyTtWhmStockOutboundById(ttwhmstockoutbound);
				} else {
					System.out.println();
					System.err.println("及时补货-按出库，此次定时任务零件号：" + iRL.getPartNoVersion() + "，没有产生补货任务............");
					System.out.println();
				}
			} // 结束： 情况1 按出库 按照wms实际出库记录算消耗

			// 【4.1】:按请求(按照sps传给wms的kitting消耗算)：按照补货路径归类 ，查询某条补货路径下面的库位零件消耗。
			List<ImmediateReplenishmentByRequestBean> requestList = twInvPalMriService.queryTimelyReplenishmentByRequest(
					tmBasDpath.getTmBasDpathId());
			for (int j = 0; j < requestList.size(); j++) {
				ImmediateReplenishmentByRequestBean iRRBean = requestList.get(j);

				// 【5.1】:遍历某条路径下面的所有的 库位零件消耗
				List<TwBasPackSkuQty> listTwBasPackSkuQty = twBasPackSkuQtyService.selectTwBasPackSkuQty(
						new Assist(Assist.andEq("tw_bas_pack_sku_qty.part_no_version", iRRBean.getPartNoVersion()),
								Assist.andEq("tw_bas_pack_sku_qty.loc_no", iRRBean.getLocNo()),
								Assist.andEq("tw_bas_pack_sku_qty.mri_status", "0")));
				TwBasPackSkuQty twBasPackSkuQty;
				Integer count = iRRBean.getOutboundQty();
				if (listTwBasPackSkuQty.size() > 0) {
					twBasPackSkuQty = listTwBasPackSkuQty.get(0);
					count += twBasPackSkuQty.getStorageQty();
				}

				// 【6.1】判断库位零件： 消耗量/包装容量是否大于1箱。如果>=1箱时，产生补货需求。
				if (count / iRRBean.getInboundPackQty() > 1) {

					// 【7.1】：生成 补货任务头表 TW_INV_PACKTRAN_HEADER
					TwInvPacktranHeader twInvPacktranHeader = new TwInvPacktranHeader();
					// 任务状态（新任务0，任务确认1，任务完成2，任务部分完成3，关闭4）
					twInvPacktranHeader.setPacktranStatus("0");
					// 补货任务单打印状态（0打印1已打印）
					twInvPacktranHeader.setPrintStatus("0");
					// 补货类型（1即时补货 2按库存消耗补货 3按累计消耗补货）
					twInvPacktranHeader.setPacktranType("1");
					// 补货路径
					twInvPacktranHeader.setRebRoad(tmBasDpath.getDpathNo());
					// 目的地
					twInvPacktranHeader.setDeliveryRec(tmBasDpath.getDeliveryRec());
					twInvPacktranHeader.setMarkStatus(1);
					twInvPacktranHeader.setCreateTime(new Date());
					twInvPacktranHeader.setTaskCreatetime(new Date());
					Map<String, Object> map = twInvPacktranHeaderService.insertNonEmptyTwInvPacktranHeader(
							twInvPacktranHeader);

					// 【8.1】：补货任务明细TW_INV_PACKTRAN_DETAIL
					TwInvPacktranDetail twInvPacktranDetail = new TwInvPacktranDetail();
					BeanUtils.copyProperties(iRRBean, twInvPacktranDetail);
					twInvPacktranDetail.setTwInvPacktranHeaderId(twInvPacktranHeader.getTwInvPacktranHeaderId());
					// 零件号
					twInvPacktranDetail.setPartNoVersion(iRRBean.getPartNoVersion());
					// 供应商编号
					twInvPacktranDetail.setSupplNo(iRRBean.getSupplNo());
					// 零件中文名称
					twInvPacktranDetail.setPartNamec(iRRBean.getPartNamec());
					// 零件基本单位
					twInvPacktranDetail.setBaseUnit(iRRBean.getBaseUnit());
					// 物料目标仓库
					twInvPacktranDetail.setAfterPartWarehouse(iRRBean.getAfterPartWarehouse());
					// 物料目标库区
					twInvPacktranDetail.setAfterPartDloc(iRRBean.getAfterPartDloc());
					// 物料目标库位
					twInvPacktranDetail.setAfterPartLoc(iRRBean.getAfterPartDloc());
					// 源仓库
					twInvPacktranDetail.setPFromWarehouseId(iRRBean.getpFromWarehouseId());
					// 源库区
					twInvPacktranDetail.setPFromDlocId(iRRBean.getpFromDlocId());
					// 源库位
					twInvPacktranDetail.setPFromLocId(iRRBean.getpFromLocId());
					// 要求补货数量
					twInvPacktranDetail.setPrePacktranQty(count);
					// 要求补货包装数量
					twInvPacktranDetail.setPacktranPacknum(count / iRRBean.getInboundPackQty());
					// 要求补货包装容量
					twInvPacktranDetail.setPacktranPackqty(iRRBean.getInboundPackQty());
					// 补货类型 1:即时补货 , 2:按库存消耗补货 3:按累计消耗补货
					twInvPacktranDetail.setPacktranType("1");
					// 创建类型（自动/人工）
					twInvPacktranDetail.setTaskCreateType("0");
					// 补货任务行状态
					twInvPacktranDetail.setTaskStatue("0");
					// 指令创建时间
					twInvPacktranDetail.setTaskCreateTime(new Date());
					// 目的地
					twInvPacktranDetail.setDeliveryRec(tmBasDpath.getDeliveryRec());
					// 补货任务单号
					twInvPacktranDetail.setPacktranSheetNo((String) map.get("packtranSheetNo"));
					// 行号
					twInvPacktranDetail.setLineNo(j + 1);
					// 是否需要分配库存(0:无来源库位需要分配|1：有来源库位，不需要分配)
					// 此处的逻辑，决定补货管理页面，是否需要分配库位的处理逻辑
					if (iRRBean.getpFromLocId() != null && iRRBean.getAfterPartDloc() != null) {
						twInvPacktranDetail.setAcallFlag("1");
					}
					if (iRRBean.getpFromLocId() == null && iRRBean.getAfterPartDloc() != null) {
						twInvPacktranDetail.setAcallFlag("0");
					}
					twInvPacktranDetail.setMarkStatus(1);
					twInvPacktranDetail.setCreateTime(new Date());
					twInvPacktranDetail.setCompanyCode(tmBasDpath.getCompanyCode());
					twInvPacktranDetailService.insertTwInvPacktranDetail(twInvPacktranDetail);

					// 【9.1】 往补货需求表(TW_INV_PAL_MRI)中，插入数据
					TwInvPalMri twInvPalMri = new TwInvPalMri();
					// 实际补货数量
					twInvPalMri.setActRepQty(0);
					// 补货任务单id
					twInvPalMri.setTwInvPacktranHeaderId((int) map.get("twInvPacktranHeaderId"));
					// 补货任务单明细id
					twInvPalMri.setTwInvPacktranDetailId(twInvPacktranDetail.getTwInvPacktranDetailId());
					// 补货任务单号
					twInvPalMri.setPacktranSheetNo((String) map.get("packtranSheetNo"));
					// 补货任务类型(1:即时补货;2:按库存消耗补货3按累计消耗补货)
					twInvPalMri.setPacktranType("1");
					twInvPalMri.setPartNoVersion(iRRBean.getPartNoVersion());
					// 供应商编号
					twInvPalMri.setSupplNo(iRRBean.getSupplNo());
					// 零件中文名称
					twInvPalMri.setPartNamec(iRRBean.getPartNamec());
					// 零件基本单位
					twInvPalMri.setBaseUnit(iRRBean.getBaseUnit());
					// 补货任务目标仓库
					twInvPalMri.setAfterPartWarehouse(iRRBean.getAfterPartWarehouse());
					// 补货任务目标库区
					twInvPalMri.setAfterPartDloc(iRRBean.getAfterPartDloc());
					// 补货任务目标库位
					twInvPalMri.setAfterPartLoc(iRRBean.getAfterPartLoc());
					// 补货任务来源仓库
					twInvPalMri.setpFromWarehouseId(iRRBean.getpFromWarehouseId());
					// 补货任务来源库区
					twInvPalMri.setpFromDlocId(iRRBean.getpFromDlocId());
					// 补货任务来源库位
					twInvPalMri.setpFromLocId(iRRBean.getpFromLocId());
					// 要求补货数量
					twInvPalMri.setPrePacktranQty(count);
					// 要求补货包装代码
					twInvPalMri.setPacktranPackno(iRRBean.getPacktranPackno());
					// 要求补货包装数量(箱数)
					twInvPalMri.setPacktranPacknum(count / iRRBean.getInboundPackQty());
					// 要求补货包装容量
					twInvPalMri.setPacktranPackqty(iRRBean.getInboundPackQty());
					// 补货任务创建时间
					twInvPalMri.setPacktranCreatetime(new Date());
					// 补货任务需求状态(0:未组织;1已组织2:补货任务完成3:关闭)
					twInvPalMri.setMriStatue("1");
					// 货主 默认''qoros''
					twInvPalMri.setCustomerid(MesConstant.DELIVERY_UNIT_NO);
					// 收货地
					twInvPalMri.setDeliveryRec(iRRBean.getDeliveryRec());
					// 补货路径
					twInvPalMri.setDpathNo(iRRBean.getDpathNo());
					// 是否翻dolley
					twInvPalMri.setDolleyFlag(iRRBean.getDolleyFlag());
					// 是否激活
					twInvPalMri.setMarkStatus(1);
					twInvPalMriService.insertNonEmptyTwInvPalMri(twInvPalMri);

					// 【10.1】 将已经使用的余量更新成 “已组织”的状态
					if (listTwBasPackSkuQty.size() > 0) {
						TwBasPackSkuQty twBasPackSkuQty3 = new TwBasPackSkuQty();
						twBasPackSkuQty3.setMriStatus("1");
						twBasPackSkuQtyService.updateNonEmptyTwBasPackSkuQty(twBasPackSkuQty3,
								new Assist(
										Assist.andEq("tw_bas_pack_sku_qty.part_no_version", iRRBean.getPartNoVersion()),
										Assist.andEq("tw_bas_pack_sku_qty.loc_no", iRRBean.getLocNo()),
										Assist.andEq("tw_bas_pack_sku_qty.mri_status", "0")));
					}

					// 【11.1】 余数表(TW_BAS_PACK_SKU_QTY)重置：对应的余数置为完成状态，另起一行记录，插入余数。
					// 余数
					Integer remainder = iRRBean.getOutboundQty() % iRRBean.getInboundPackQty();
					if (remainder > 0) {
						TwBasPackSkuQty twBasPackSkuQty2 = new TwBasPackSkuQty();
						// 零件号
						twBasPackSkuQty2.setPartNoVersion(iRRBean.getPartNoVersion());
						// 库位
						twBasPackSkuQty2.setLocNo(iRRBean.getLocNo());
						// 余量
						twBasPackSkuQty2.setStorageQty(remainder);
						// 组织状态0未组织1已组织
						twBasPackSkuQty2.setMriStatus("0");
						twBasPackSkuQty2.setCreateTime(new Date());
						twBasPackSkuQtyService.insertTwBasPackSkuQty(twBasPackSkuQty2);
					}

					// 【12.1】完成后需要将出库记录(TT_WHM_STOCK_OUTBOUND)补货组织状态置为完成
					TtWhmStockOutbound ttwhmstockoutbound = new TtWhmStockOutbound();
					ttwhmstockoutbound.setTtWhmStockOutboundId(iRRBean.getTe_kitting_wms_confirm_id());
					// 补货需求状态(0:未组织,1:已组织)
					ttwhmstockoutbound.setMriStatus("1");
					ttWhmStockOutboundService.updateNonEmptyTtWhmStockOutboundById(ttwhmstockoutbound);
				} else {
					System.out.println();
					System.err.println("及时补货-按请求，此次定时任务零件号：" + iRRBean.getPartNoVersion() + "，没有产生补货任务............");
					System.out.println();
				}
			}
			// 按请求(按照sps传给wms的kitting消耗算) 结束
		} // 遍历所有的补货路径

	}

}
